//package com.gaga.console.core.service.impl;
//
//import com.gaga.common.enums.PlayerType;
//import com.gaga.common.enums.PushMessageType;
//import com.gaga.common.enums.ScriptType;
//import com.gaga.common.utils.AudioPlayerUtils2;
//import com.gaga.console.base.entity.sse.PushMessageDto;
//import com.gaga.console.base.utils.SseEmitterServerUtils;
//import com.gaga.console.core.entity.dto.AudioDto;
//import com.gaga.console.core.service.AudioQueueService;
//import com.gaga.console.core.service.BvConfigService;
//import com.gaga.console.core.service.MainVideoService;
//import com.gaga.metadata.common.utils.StringUtils;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//
//import java.io.BufferedWriter;
//import java.io.File;
//import java.io.FileWriter;
//import java.time.LocalDateTime;
//import java.time.format.DateTimeFormatter;
//import java.util.Optional;
//import java.util.concurrent.ConcurrentLinkedDeque;
//import java.util.concurrent.ExecutorService;
//import java.util.concurrent.Executors;
//import java.util.concurrent.ThreadLocalRandom;
//
//@Service
//@Slf4j
//public class AudioQueueServiceImplbackup implements AudioQueueService {
//    private final ConcurrentLinkedDeque<AudioDto> anchorQueue = new ConcurrentLinkedDeque<>();
//    private final ConcurrentLinkedDeque<AudioDto> assistantQueue = new ConcurrentLinkedDeque<>();
//    private final ExecutorService anchorExecutor = Executors.newSingleThreadExecutor();
//    private final ExecutorService assistantExecutor = Executors.newSingleThreadExecutor();
//
//    private final AudioPlayerUtils2 anchorAudioPlayer = new AudioPlayerUtils2();
//    private final AudioPlayerUtils2 assistantAudioPlayer = new AudioPlayerUtils2();
//
//    private volatile boolean isAnchorPlaying = false;
//    private volatile boolean isAssistantPlaying = false;
//
//    @Autowired
//    private BvConfigService bvConfigService;
//
//    @Autowired
//    private MainVideoService mainVideoService;
//
//    /**
//     * 将文件插入到第一条
//     *
//     * @param audioDto 文件名
//     * @param type     播放器类型（决定文件加入哪个队列）
//     *                 如果类型为 ANCHOR，则加入锚点队列并尝试播放；
//     *                 如果类型为 ASSISTANT，则加入助手队列并尝试播放。
//     * @throws IllegalArgumentException 如果文件名或播放器类型为空。
//     */
//    @Override
//    public void insertFirstToQueue(AudioDto audioDto, PlayerType type) {
//        if (type == PlayerType.ANCHOR) {
//            // 将文件加入锚点队列
//            anchorQueue.addFirst(audioDto);
//            // 尝试开始锚点播放
//            tryStartAnchorPlayback();
//        } else {
//            // 将文件加入助手队列
//            assistantQueue.addFirst(audioDto);
//            // 尝试开始助手播放
//            tryStartAssistantPlayback();
//        }
//    }
//
//    @Override
//    public void addToQueue(AudioDto audioDto, PlayerType type) {
//        if (type == PlayerType.ANCHOR) {
//            // 将文件加入锚点队列
//            anchorQueue.addLast(audioDto);
//            // 尝试开始锚点播放
//            tryStartAnchorPlayback();
//        } else {
//            // 将文件加入助手队列
//            assistantQueue.addLast(audioDto);
//            // 尝试开始助手播放
//            tryStartAssistantPlayback();
//        }
//    }
//
//    @Override
//    public void stopLive() {
//        anchorQueue.clear();
//        assistantQueue.clear();
//        anchorAudioPlayer.stop();
//        anchorAudioPlayer.stop();
//        isAnchorPlaying = false;
//        isAssistantPlaying = false;
//    }
//
//    @Override
//    public Integer getQueueSize(PlayerType playerType) {
//        if (playerType == PlayerType.ANCHOR) {
//            return anchorQueue.size();
//        } else {
//            return assistantQueue.size();
//        }
//    }
//
//    @Override
//    public Integer getQueueSizeByScriptType(ScriptType scriptType) {
//        return (int) anchorQueue.stream()
//                .filter(dto -> dto.getScriptType() == scriptType)
//                .count();
//    }
//
//
//    /**
//     * 尝试启动锚点播放
//     * 此方法用于检查当前是否可以启动锚点播放如果当前没有锚点正在播放且锚点队列不为空，则开始播放
//     * 此方法是同步的，以确保并发情况下锚点播放状态的一致性
//     */
//    private synchronized void tryStartAnchorPlayback() {
//        // 检查当前是否有锚点正在播放以及锚点队列是否为空
//        if (!isAnchorPlaying && !anchorQueue.isEmpty()) {
//            // 设置锚点播放状态为正在播放
//            isAnchorPlaying = true;
//            // 提交任务以处理锚点队列
//            anchorExecutor.submit(this::processAnchorQueue);
//        }
//    }
//
//    /**
//     * 尝试启动助手播放功能
//     * 此方法用于检查当前是否可以启动助手播放，并在条件满足时开始播放
//     * 它首先检查当前是否有助手播放正在进行（通过isAssistantPlaying判断），以及助手队列是否为空（通过assistantQueue.isEmpty()判断）
//     * 如果当前没有助手播放正在进行且队列不为空，则将isAssistantPlaying设置为true，并提交任务到助手执行器（assistantExecutor）以处理助手队列
//     * <p>
//     * 注：此方法是同步的（synchronized），以确保并发情况下对助手播放状态和队列的访问是线程安全的
//     */
//    private synchronized void tryStartAssistantPlayback() {
//        // 检查当前是否有助手播放正在进行，以及助手队列是否为空
//        if (!isAssistantPlaying && !assistantQueue.isEmpty()) {
//            // 设置助手播放状态为正在进行
//            isAssistantPlaying = true;
//            // 提交处理助手队列的任务到助手执行器
//            assistantExecutor.submit(this::processAssistantQueue);
//        }
//    }
//
//    /**
//     * 处理锚点队列
//     * 本方法调用通用的processQueue方法来处理锚点类型的播放队列
//     * 它专门处理与锚点相关的音频播放逻辑
//     */
//    private void processAnchorQueue() {
//        // 调用处理队列的方法，指定播放器类型为锚点，传递锚点队列和锚点音频播放器作为参数
//        processQueue(PlayerType.ANCHOR, anchorQueue, anchorAudioPlayer);
//    }
//
//    /**
//     * 处理助理队列中的音频播放请求
//     * 此方法通过调用更通用的processQueue方法来处理助理的音频播放队列
//     * 它专门用于处理类型为ASSISTANT的玩家的音频队列
//     */
//    private void processAssistantQueue() {
//        // 调用通用的processQueue方法，传入助理特定的队列和音频播放器实例
//        processQueue(PlayerType.ASSISTANT, assistantQueue, assistantAudioPlayer);
//    }
//
//    /**
//     * 处理播放队列中的音频文件
//     *
//     * @param type   播放器类型，用于区分不同类型的音频播放
//     * @param queue  音频文件队列，存储待播放的音频文件名
//     * @param player 音频播放实用工具类实例，用于实际的音频播放操作
//     */
//    private void processQueue(PlayerType type, ConcurrentLinkedDeque<AudioDto> queue, AudioPlayerUtils2 player) {
//        // 从队列中获取下一个音频文件
//        AudioDto audioDto = queue.poll();
//
//        String file = audioDto.getAudioFilePath();
//        // 如果队列中还有文件，则尝试播放
//        File awvFile = new File(file);
//
//        if (file != null && awvFile.exists()) {
//            if (audioDto.getIntervalMin() != null && audioDto.getIntervalMax() != null) {
//                int randomSleepTime = ThreadLocalRandom.current().nextInt(audioDto.getIntervalMin(), audioDto.getIntervalMax() + 1);
//                try {
//                    Thread.sleep(randomSleepTime);
//                } catch (InterruptedException e) {
//                    // 处理线程中断（例如取消任务）
//                    Thread.currentThread().interrupt(); // 恢复中断状态
//                    log.error("休眠被中断: " + e.getMessage());
//                }
//            }
//            // 尝试播放音频文件
//            playAudio(audioDto, type, player, queue);
//        }
//    }
//
//    private static void pushMessage(AudioDto audioDto, ConcurrentLinkedDeque<AudioDto> anchorQueue) {
//        if (StringUtils.isBlank(audioDto.getChannelId()) || StringUtils.isBlank(audioDto.getText())) {
//            return;
//        }
////
////        Optional<AudioDto> secondOpt = anchorQueue.stream()
////                .filter(item -> item.getScriptType().equals(audioDto.getScriptType()))
//////                .skip(1)
////                .findFirst();
//
//        PushMessageDto pushMessageDto = new PushMessageDto();
//        pushMessageDto.setMessage(audioDto.getText());
//
//        switch (audioDto.getScriptType()) {
//            case INSERT_AUDIO:
//                pushMessageDto.setType(PushMessageType.insertAudioWaitPlay);
//                break;
//            case KEYWORD:
//                pushMessageDto.setType(PushMessageType.keywordWaitPlay);
//                break;
//            case USER_ENTER:
//                pushMessageDto.setType(PushMessageType.userEnterWaitPlay);
//                break;
//            case RANDOM_AUDIO:
//                pushMessageDto.setType(PushMessageType.randomAudioWaitPlay);
//                break;
//            case MAIN_AUDIO:
//                pushMessageDto.setType(PushMessageType.mainAudioPlayFile);
//                pushMessageDto.setPlayScriptId(audioDto.getPlayScriptId());
//                break;
//            default:
//                break;
//        }
//
//        if (pushMessageDto.getType() != null) {
//            //推送待播放消息
//            SseEmitterServerUtils.sendMessage(audioDto.getChannelId(), pushMessageDto);
//        }
//    }
//
//    private static void clearGenMessage(AudioDto audioDto, ConcurrentLinkedDeque<AudioDto> anchorQueue) {
//
//        //推送待播放后将待生成的消息清空
//        PushMessageDto pushNullMessageDto = new PushMessageDto();
//
//        Optional<AudioDto> thirdOpt = anchorQueue.stream()
//                .filter(item -> item.getScriptType().equals(audioDto.getScriptType()))
//                .skip(2)
//                .findFirst();
//
//        PushMessageDto pushMessageDto = new PushMessageDto();
//        if (thirdOpt.isPresent()) {
//            pushMessageDto.setMessage("");
//        }
//
//        switch (audioDto.getScriptType()) {
//            case INSERT_AUDIO:
//                pushNullMessageDto.setType(PushMessageType.insertAudioWaitGen);
//                break;
//            case KEYWORD:
//                pushNullMessageDto.setType(PushMessageType.keywordWaitGen);
//                break;
//            case USER_ENTER:
//                pushNullMessageDto.setType(PushMessageType.userEnterWaitGen);
//                break;
//            case RANDOM_AUDIO:
//                pushNullMessageDto.setType(PushMessageType.randomAudioWaitGen);
//                break;
//            default:
//                break;
//        }
//
//        if (pushNullMessageDto.getType() != null) {
//            //将待生成区域置空
//            SseEmitterServerUtils.sendMessage(audioDto.getChannelId(), pushNullMessageDto);
//        }
//    }
//
//    private static void clearPlayMessage(AudioDto audioDto) {
//
//        //推送待播放后将待生成的消息清空
//        PushMessageDto pushNullMessageDto = new PushMessageDto();
//        pushNullMessageDto.setMessage("");
//
//        switch (audioDto.getScriptType()) {
//            case INSERT_AUDIO:
//                pushNullMessageDto.setType(PushMessageType.insertAudioWaitPlay);
//                break;
//            case KEYWORD:
//                pushNullMessageDto.setType(PushMessageType.keywordWaitPlay);
//                break;
//            case USER_ENTER:
//                pushNullMessageDto.setType(PushMessageType.userEnterWaitPlay);
//                break;
//            case RANDOM_AUDIO:
//                pushNullMessageDto.setType(PushMessageType.randomAudioWaitPlay);
//                break;
//            default:
//                break;
//        }
//
//        if (pushNullMessageDto.getType() != null) {
//            //将待生成区域置空
//            SseEmitterServerUtils.sendMessage(audioDto.getChannelId(), pushNullMessageDto);
//        }
//    }
//
//    /**
//     * 播放音频文件
//     *
//     * @param audioDto 音频文件的路径
//     * @param type     播放器类型，决定播放完毕后的行为
//     * @param player   音频播放器实例，用于控制音频播放
//     */
//    private void playAudio(AudioDto audioDto, PlayerType type, AudioPlayerUtils2 player, ConcurrentLinkedDeque<AudioDto> queue) {
//        try {
//            // 初始化播放器，设置音频文件路径和设备
//            player.init(audioDto.getAudioFilePath(), bvConfigService.getSelectDeviceName());
//            // 设置播放完成后的回调
//            player.setOnPlaybackFinished(() -> {
//                log.info("播放音频完成: " + audioDto.getAudioFilePath());
//
//                //清理待播放消息
//                clearPlayMessage(audioDto);
//
//                // 自动触发下一个播放
//                if (type == PlayerType.ANCHOR) {
//                    isAnchorPlaying = false;
//                    tryStartAnchorPlayback();
//                } else {
//                    isAssistantPlaying = false;
//                    tryStartAssistantPlayback();
//                }
//            });
//
//            //推送等待播放消息
//            pushMessage(audioDto, queue);
//            //将待生成文件清理
//            clearGenMessage(audioDto, queue);
//
//            sendMainLog(type, audioDto);
//
//            mainVideoService.matchMainVideo(audioDto);
//
////            player.setSpeed(audioDto.getSpeed());
//            player.setVolume(audioDto.getVolume());
//            player.play();
//
////            while (player.getClip().isRunning()) {
////                ThreadUtil.sleep(100);
////            }
//            log.info("开始播放音频: " + audioDto.getAudioFilePath());
//        } catch (Exception e) {
//            // 打印异常信息
//            e.printStackTrace();
//        }
//    }
//
//
//    private void sendMainLog(PlayerType type, AudioDto audioDto) {
//        // 开始播放音频
//        PushMessageDto pushMessageDto = new PushMessageDto();
//        StringBuilder stringBuilder = new StringBuilder();
//        stringBuilder.append("【").append(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))).append("】");
//        stringBuilder.append("【").append(audioDto.getScriptType().getInfo()).append("】");
//        if (StringUtils.isNotBlank(audioDto.getPlayFileName())) {
//            stringBuilder.append("【").append(audioDto.getPlayFileName()).append("】");
//        }
//        stringBuilder.append("【").append(type.getDisplayName()).append("】");
//        if (audioDto.getIsSmartReply()) {
//            stringBuilder.append("【原文本：").append(audioDto.getOldText()).append("】");
//            stringBuilder.append("【泛化后：").append(audioDto.getText()).append("】");
//        } else {
//            stringBuilder.append("【文本：").append(audioDto.getText()).append("】");
//        }
//
//        pushMessageDto.setMessage(stringBuilder.toString());
//        pushMessageDto.setType(PushMessageType.playLog);
//        SseEmitterServerUtils.sendMessage(audioDto.getChannelId(), pushMessageDto);
//
//        if (StringUtils.isNotBlank(audioDto.getPlayLogPath())) {
//            // 追加写入文件
//            try (BufferedWriter writer = new BufferedWriter(
//                    new FileWriter(audioDto.getPlayLogPath(), true))) { // true 表示追加模式
//                writer.write(stringBuilder.toString());
//                writer.newLine(); // 添加换行符
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//        }
//    }
//
//}
